home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / STUTTGART / GRAPHICS / TOOLS / GS / !GhostScr / gs_cmap.ps < prev    next >
Text File  |  1996-02-10  |  7KB  |  231 lines
  1. %    Copyright (C) 1995 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % ProcSet for implementing CMap resource.
  19. % When this is run, systemdict is still writable.
  20.  
  21. %**************** This file is not ready for use:
  22. %    - Rearranged fonts are not implemented.
  23. %    - It has never been tested on a real font.
  24.  
  25. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  26. .currentglobal true .setglobal
  27.  
  28. /GS_CMapInit_ProcSet 30 dict dup begin
  29.  
  30. % ---------------- CMap operators ---------------- %
  31.  
  32. % We create the following structures for character code mapping.
  33. %    Map - a multi-level array indexed by the successive bytes of
  34. %      the character code.  All of the arrays are read-only.
  35. %    NotdefMap - the same.
  36.  
  37. % ------ Font-level operators ------ %
  38.  
  39. % composefont doesn't appear in CMap files -- it's documented in
  40. % the "PostScript Language Reference Manual Supplement".
  41. /composefont        % <name> <cmap|cmapname> <fonts> composefont <font>
  42.  { exch dup /dicttype ne { /CMap findresource } if
  43.    10 dict
  44.      dup /FontType 0 put
  45.      dup /FMapType 9 put
  46.      dup /CMap 5 -1 roll put
  47.      dup /Encoding [ 0 1 6 index length 1 sub { } for ] put
  48.      dup /FDepVector 4 -1 roll put
  49.    /Font defineresource
  50.  } bind def
  51.  
  52. /begincmap        % - begincmap -
  53.  { /Map 256 array def
  54.    /NotdefMap 256 array def
  55.  } bind def
  56. /endcmap        % - endcmap -
  57.  { /Map Map .endmap def
  58.    /NotdefMap NotdefMap .endmap def
  59.  } bind def
  60.  
  61. /begincodespacerange    % <count> begincodespacerange -
  62.  { pop mark
  63.  } bind def
  64. /endcodespacerange    % <code_lo> <code_hi> ... endcodespacerange -
  65.  { counttomark 2 idiv
  66.     { 2 copy Map .addcodespacerange NotdefMap .addcodespacerange
  67.     } repeat pop
  68.  } bind def
  69.  
  70. /.addcodespacerange    % <code_lo> <code_hi> <map> .addcodespacerange -
  71.  { 2 index length 1 eq
  72.     { 2 { 3 -1 roll 0 get } repeat 1 exch
  73.        { 2 copy 0 put pop } for pop
  74.     }
  75.     { 2 index 0 get 1 3 index 0 get
  76.       6 -2 roll
  77.       2 { 1 1 index length 1 sub getinterval 6 1 roll } repeat
  78.         % Stack: lo hi map lo0 1 hi0
  79.        { 2 copy get null eq { 2 copy 256 array put } if
  80.          4 copy get .addcodespacerange pop
  81.        }
  82.       for pop pop pop
  83.     }
  84.    ifelse
  85.  } bind def
  86. /.endmap        % <map> .endmap <map>
  87.  { dup type /arraytype eq { dup { .endmap exch } forall astore readonly } if
  88.  } bind def
  89.  
  90. /usecmap        % <CMap_name> usecmap -
  91.  { /CMap findresource
  92.    dup length dict .copydict
  93.    currentdict end exch .copydict begin
  94.  } bind def
  95.  
  96. % ------ Rearranged font operators ------ %
  97.  
  98. /beginrearrangedfont    % <font_name> <font*> beginrearrangedfont -
  99.  {    (NOT IMPLEMENTED YET.\n) print flush
  100.  } bind def
  101. /endrearrangedfont    % - endrearrangedfont -
  102.  {    (NOT IMPLEMENTED YET.\n) print flush
  103.  } bind def
  104.  
  105. /usefont        % <fontID> usefont -
  106.  {    (NOT IMPLEMENTED YET.\n) print flush
  107.  } bind def
  108.  
  109. /beginusematrix        % <fontID> beginusematrix -
  110.  {    (NOT IMPLEMENTED YET.\n) print flush
  111.  } bind def
  112. /endusematrix        % <matrix> endusematrix -
  113.  {    (NOT IMPLEMENTED YET.\n) print flush
  114.  } bind def
  115.  
  116. % ------ Character name/code selector operators ------ %
  117.  
  118. /beginbfchar        % <count> beginbfchar -
  119.  { pop mark
  120.  } bind def
  121. /endbfchar        % <code> <to_code|charname> ... endbfchar
  122.  { Map .endmapchar /Map exch store pop
  123.  } bind def
  124.  
  125. /beginbfrange        % <count> beginbfrange -
  126.  { pop mark
  127.  } bind def
  128. /endbfrange        % <code_lo> <code_hi> <to_code|(charname*)> ...
  129.             %   endbfrange -
  130.  { Map counttomark 3 idiv { .addbfrange } repeat /Map exch store pop
  131.  } bind def
  132.  
  133. /.addbfrange        % <code_lo> <code_hi> <to_code|(charname*)> <map>
  134.             %   .addbfrange <map>
  135.  { 1 index type /stringtype eq
  136.     {  { dup length string copy dup dup length 1 sub 2 copy get 1 add put }
  137.       exch .addmaprange
  138.     }
  139.     { 2 dict begin exch /codes 1 index def 0 get exch
  140.        { codes dup length 1 sub 1 exch getinterval /codes 1 index def
  141.      dup length 0 gt { 0 get } if
  142.        }
  143.       exch .addmaprange end
  144.     }
  145.    ifelse exch pop
  146.  } bind def
  147.  
  148. % ------ CID selector operators ------ %
  149.  
  150. /begincidchar        % <count> begincidchar -
  151.  { pop mark
  152.  } bind def
  153. /endcidchar        % <code> <cid> ... endcidchar -
  154.  { Map .endmapchar /Map exch store pop
  155.  } bind def
  156.  
  157. /begincidrange        % <count> begincidrange -
  158.  { pop mark
  159.  } bind def
  160. /endcidrange        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  161.  { Map counttomark 3 idiv { { 1 add } exch .addmaprange exch pop } repeat
  162.    /Map exch store pop
  163.  } bind def
  164.  
  165. /.endmapchar        % <code> <value> ... <map> .endmapchar -
  166.  { counttomark 2 idiv
  167.     { 2 index 3 1 roll { } exch .addmaprange exch pop
  168.     } repeat exch pop
  169.  } bind def
  170.  
  171. /.addmaprange        % <code_lo> <code_hi> <value_base> <next_proc> <map>
  172.             %   .addcidrange <value_next> <map>
  173.  {    % We may be updating a (partly) read-only map from another CMap.
  174.     % If so, implement copy-on-write.
  175.    dup wcheck not { dup length array copy } if
  176.    4 index length 1 eq
  177.     { 2 { 5 -1 roll 0 get } repeat 1 exch
  178.        {    % Stack: value proc map code
  179.      2 copy 5 index put pop
  180.      3 -1 roll 2 index exec 3 1 roll
  181.        } for
  182.     }
  183.     { 4 index 0 get 1 5 index 0 get
  184.       8 -2 roll
  185.       2 { 1 1 index length 1 sub getinterval 8 1 roll } repeat
  186.         % Stack: lo hi next proc map lo0 1 hi0
  187.        { 6 copy get .addmaprange
  188.         % Stack: lo hi oldnext proc map i next submap
  189.      exch 6 1 roll 5 -1 roll pop
  190.         % Stack: lo hi next proc map i submap
  191.      3 copy put pop pop
  192.        }
  193.       for 5 -2 roll pop pop
  194.     }
  195.    ifelse exch pop
  196.  } bind def
  197.  
  198. % ------ notdef operators ------ %
  199.  
  200. /beginnotdefchar    % <count> beginnotdefchar -
  201.  { pop mark
  202.  } bind def
  203. /endnotdefchar        % <code> <cid> ... endnotdefchar -
  204.  { counttomark 2 idiv { 1 index exch .addnotdefrange } repeat pop
  205.  } bind def
  206.  
  207. /beginnotdefrange    % <count> beginnotdefrange -
  208.  { pop mark
  209.  } bind def
  210. /endnotdefrange        % <code_lo> <code_hi> <cid> ... endnotdefrange -
  211.  { counttomark 3 idiv { .addnotdefrange } repeat pop
  212.  } bind def
  213.  
  214. /.addnotdefrange    % <code_lo> <code_hi> <cid_base> .addnotdefrange -
  215.  { { } NotdefMap .addmaprange /NotdefMap exch store pop
  216.  } bind def
  217.  
  218. % ---------------- Resource category definition ---------------- %
  219.  
  220. end readonly def
  221.  
  222. /defineresource where
  223.  { pop
  224.    /CMap /Generic /Category findresource dup length dict .copydict
  225.    /Category defineresource pop
  226.    /CMapInit GS_CMapInit_ProcSet /ProcSet defineresource pop
  227.  }
  228. if
  229.  
  230. .setglobal
  231.